Posted on
• Artificial Intelligence

How Artificial Intelligence Can Refactor Legacy Bash Scripts

Author
  • User
    linuxbash
    Posts by this author
    Posts by this author

How Artificial Intelligence Can Refactor Legacy Bash Scripts

If your infrastructure still relies on Bash scripts written years ago, you’re not alone. Those scripts power backups, deployments, data pipelines—yet they’re often brittle, hard to read, and scary to touch. Here’s the good news: with the right workflow, AI can help you safely refactor legacy Bash into clean, testable, maintainable code—without breaking production.

This post shows why AI is genuinely useful for shell refactors, and gives you a practical, tool-based workflow you can run in a terminal today.

Why use AI for legacy Bash?

  • Context compression: LLMs are good at digesting long, inconsistent scripts and proposing coherent structure (functions, error handling, parameterization) while preserving behavior.

  • Pattern awareness: AI has “seen” countless shell idioms and common footguns. It can suggest modern, safer patterns (set -Eeuo pipefail, traps, mktemp, jq).

  • Faster iterations: You can round-trip changes quickly—ask for refactors, add constraints (POSIX sh vs Bash), and generate tests from usage examples.

  • Skills bridge: Not every team member is a Bash expert. AI can help non-specialists contribute safe changes by scaffolding improvements and test cases.

None of this replaces your judgment. The key is to pair AI with static analysis, formatting, and tests—so the machine proposes, and your toolchain verifies.

Install the baseline toolchain

We’ll use five widely packaged tools: ShellCheck (linter), shfmt (formatter), Bats (tests), jq (JSON parsing), and ripgrep (fast search). Install them with your package manager:

  • Debian/Ubuntu (apt):

    sudo apt update
sudo apt install -y shellcheck shfmt bats jq ripgrep

  • Fedora/RHEL/CentOS Stream (dnf):

    sudo dnf install -y ShellCheck shfmt bats jq ripgrep

  • openSUSE (zypper):

    sudo zypper refresh
sudo zypper install -y ShellCheck shfmt bats jq ripgrep

Verify:

shellcheck --version
shfmt -version
bats -v
jq --version
rg --version

A 4-step AI refactor workflow for Bash

1) Baseline the script with analysis and formatting

Before asking AI for anything, pin down current behavior and risks.

  • Lint and format:

    shellcheck -S style -x path/to/legacy.sh
shfmt -w -i 2 -ci -sr path/to/legacy.sh
    • -S style surfaces style and safety suggestions.
    • -x follows sourced files (useful if your script sources others).
    • shfmt normalizes indentation and structure, making diffs easier to review.

  • Create a quick, executable transcript of current behavior:

    bash -x path/to/legacy.sh arg1 arg2 2>&1 | tee /tmp/legacy.trace

    Save representative inputs and outputs. You’ll use them to verify the refactor.

  • Write a minimal Bats test from what you just observed:

    mkdir -p test
cat > test/legacy.bats <<'EOF'
#!/usr/bin/env bats

setup() {
TEST_TMPDIR="$(mktemp -d)"
}

teardown() {
rm -rf "$TEST_TMPDIR"
}

@test "prints status for known server" {
run bash path/to/legacy.sh example.local
[ "$status" -eq 0 ]
[[ "$output" =~ "OK" ]]
}
EOF

bats test

This gives you a safety net so AI suggestions don’t regress behavior.

2) Use AI to isolate side effects and apply safe Bash idioms

Feed the script and ShellCheck findings to your LLM of choice. A good prompt:

Refactor this Bash script. Goals:

- Preserve behavior and exit codes.

- Add `set -Eeuo pipefail` and robust `trap`-based cleanup.

- Replace temp-file races with `mktemp`.

- Avoid UUOC, quote variables, and handle spaces/newlines safely.

- Prefer `jq` for JSON parsing instead of `sed/grep`.

- Extract pure functions for logic; move I/O (curl, rm, mv) to thin wrappers.

- Keep it Bash (not POSIX sh). Include comments explaining decisions.

ShellCheck findings:
<PASTE shellcheck output>

Original script:
<PASTE script here>

Here’s a typical legacy snippet and a safe refactor you can aim for:

Legacy:

#!/bin/bash
set -e
TMP=/tmp/data.txt
if [ ! -z "$1" ]; then
  SERVER=$1
fi
curl -s http://$SERVER/api | sed 's/"/\\"/g' > $TMP
cat $TMP | grep status | cut -d: -f2 | tr -d '",' || true
rm $TMP

Refactored:

#!/usr/bin/env bash
set -Eeuo pipefail

server=${1:?Usage: $0 <server>}
tmpfile="$(mktemp -t data.XXXXXX)"
trap 'rm -f "$tmpfile"' EXIT

curl -fsS "http://${server}/api" -o "$tmpfile"
jq -r '.status' < "$tmpfile"

Why this is better:

  • set -Eeuo pipefail surfaces errors early.

  • mktemp + trap eliminates temp-file collisions and leaks.

  • curl -fsS fails fast on HTTP errors.

  • jq replaces brittle sed/grep parsing.

Re-run your tests:

bats test

If anything fails, iterate with the AI and include the failing output.

3) Automate context extraction to improve AI prompts

LLMs do better with focused, high-signal context rather than entire repos. Use ripgrep to gather just what’s relevant:

  • Find all scripts and shell-related comments:

    rg -n --glob '**/*.sh' --glob '!vendor/**' .
rg -n 'shellcheck disable|TODO|FIXME|trap|mktemp' -S

  • Feed ShellCheck output alongside the script:

    shellcheck -S style -x path/to/legacy.sh > /tmp/legacy.shellcheck.txt

  • Construct a compact prompt file:

    {
echo "Please refactor per the rules below and explain your changes in comments."
echo
echo "Rules:"
echo "1) set -Eeuo pipefail; 2) strict quoting; 3) mktemp + trap; 4) use jq for JSON; 5) functions for pure logic."
echo
echo "ShellCheck findings:"
cat /tmp/legacy.shellcheck.txt
echo
echo "Script:"
sed -n '1,200p' path/to/legacy.sh
} > /tmp/prompt.txt

    Copy /tmp/prompt.txt into your AI tool. This “context pack” keeps the model focused on concrete issues and keeps you in control.

4) Replace fragile parsing and side effects with robust primitives

A common source of bugs in old Bash is parsing with grep/sed/awk where a dedicated tool would be safer.

  • JSON: prefer jq

    curl -fsS "https://api/service" | jq -r '.items[] | select(.active) | .name'

  • CSV/TSV: use awk or mlr (Miller). If you prefer to stay minimal:

    awk -F, 'NR>1 && $3=="enabled" {print $1}' data.csv

  • File detection: use bash’s [[ ]] and globs instead of parsing ls:

    shopt -s nullglob
for f in /var/log/app/*.log; do
[[ -s "$f" ]] || continue
# process "$f"
done

You can ask AI: “Replace ad-hoc parsing with jq/awk while preserving behavior; avoid subshell-heavy pipelines; explain any changed assumptions.”

Re-test and lint:

shfmt -d .
shellcheck -S style -x **/*.sh
bats -r test

If your shell doesn’t expand **, use find/xargs or enable globstar:

shopt -s globstar
shellcheck -S style -x **/*.sh

A realistic mini-case study

Problem: A 1,200-line provisioning script intermittently failed and left temp files behind.

What we did:

  • Ran ShellCheck and shfmt; 300+ warnings surfaced quoting issues and useless use of cat.

  • Wrote three Bats tests based on production runs (idempotent re-run, error on 404, prints final status).

  • Prompted an LLM to:

    • Add set -Eeuo pipefail and trap-based cleanup.
    • Extract functions: read_config, fetch_metadata, provision_host.
    • Replace sed/grep JSON parsing with jq.
    • Parameterize environment instead of hard-coded paths.

  • Iterated twice to fix two failing tests (curl error handling and a missing default).

  • Outcome: 40% fewer lines, 0 temp-file leaks, and mean runtime dropped ~30% by removing redundant pipes and combining network calls.

Key observation: The AI’s first pass was good, but the tests + ShellCheck guided the final, safe version.

Tips for successful AI-assisted Bash refactors

  • Constrain the model: Explicitly say “Bash (not POSIX sh)”, or the reverse if you need portability.

  • Keep changes small: Tackle one script or one concern (error handling, parsing, parameterization) at a time.

  • Lock in style: Run shfmt before and after refactors to reduce noisy diffs.

  • Gate with tests: Even a couple of Bats tests catch surprising regressions quickly.

  • Don’t over-engineer: It’s okay to keep simple sed/awk one-liners when they’re robust and well-commented.

Quick-reference commands

  • Lint and format:

    shellcheck -S style -x script.sh
shfmt -w -i 2 -ci -sr script.sh

  • Run tests:

    bats -r test

  • Search the repo for shell smells:

    rg -n 'shellcheck disable|mktemp|trap|set -e|set -u' -S

Conclusion and next steps

AI won’t magically fix legacy shell, but combined with ShellCheck, shfmt, and Bats, it becomes a powerful accelerator. You get cleaner scripts, safer error handling, and confidence from tests—without rewriting everything from scratch.

Your 60-minute starter plan: 1) Install the toolchain (ShellCheck, shfmt, Bats, jq, ripgrep) using apt/dnf/zypper. 2) Pick one high-value script; run ShellCheck and shfmt. 3) Write 1–3 Bats tests from real runs. 4) Prompt your AI with the script plus ShellCheck output; apply one focused refactor. 5) Re-run tests, iterate, and commit.

Have a gnarly script you’d like help with? Paste a redacted version plus ShellCheck output and I’ll suggest a prompt and refactor plan tailored to it.

Related posts