Automasi Bukan Soal Tools, tapi Soal Mindset: Kenapa Lo Masih Ngelakuin Hal yang Sama Berkali-kali

Gue pernah ngalakuin hal yang sama tiap Senin pagi. Pull 5 repo, install dependencies, run database migration, start 4 service. 45 menit. Gue pikir "wajar, project ribet, setup memang lama." 6 bulan jalan. Terus temen liat dan bilang: "lo masih manual?"

Dia bikin 1 script 20 baris. Senin pagi berikutnya, gue jalanin ./bootstrap.sh. 30 detik. Semua service running, semua migration applied, semua repo updated. 45 menit jadi 30 detik. Gue ngerasa bodoh - 6 bulan * 45 menit * 4 minggu = 18 jam setahun. Setaun kerja, 18 jam hilang cuma buat setup repetitive.

Itu momen gue sadar: automasi itu bukan soal tools. Bukan soal "belajar bash scripting" atau "belajar Makefile." Automasi itu soal mindset - sadar kapan lo ngelakuin hal yang sama berkali-kali, dan punya instinct buat bilang "ini musti di-automasi."

---

Filosofi "If You Do It Twice, Automate It"

Aturan sederhana yang gue pegang sekarang: kalau lo ngelakuin hal yang sama 2 kali, otomatisasi. Bukan 3 kali, bukan 10 kali. 2.

Kenapa 2? Karena:
• Kali pertama: lo belajar. Lo ngerti friction-nya, step-nya, error-nya.
• Kali kedua: lo ngulang. Friction-nya sama. Step-nya sama. Error-nya (kemungkinan) sama. Ini sinyal: lo bakal ngelakuin ini lagi.
• Kali ketiga dst: lo udah automasi dari kali kedua, jadi tinggal run.

Dev yang nunda automasi bilang "nanti aja, sekarang lagi sibuk." Tapi 10 kali manual = 10x waktu hilang. 1x waktu bikin script = 1x invest. Beda mindset.

Tapi ada nuansa. Automasi punya biaya:
• Waktu nulis script
• Waktu maintenance kalau script break
• Cognitive overhead - script bisa jadi black box, orang lupa cara manual

Yang musti diautomasi: repetitive, predictable, low-risk. Yang gak usah: one-off, eksperimental, high-risk (production data migration, merge conflict resolution).

---

Apa yang Gue Automasi (Bukan Listicle, Tapi Filosofi)

Gue gak punya "X tools yang gue pake." Gue punya kategori yang automasi, dan tiap kategori punya pola sendiri.

Project bootstrap. Tiap project baru butuh: init git, install deps, setup linting, setup testing, bikin folder structure. Dulunya 30 menit manual. Sekarang 1 script:

#!/bin/bash
bootstrap.sh - dipake tiap mulai project baru

PROJECT=$1
mkdir -p $PROJECT/{src,tests,docs}
cd $PROJECT

git init
npm init -y
npm install -D typescript eslint prettier vitest @types/node
npx tsc --init
npx eslint --init

Template files
cat > .gitignore README.md /dev/null; then
echo "✓ Deploy successful, health check passed"
else
echo "✗ Health check failed - investigate"
# Could auto-rollback here
exit 1
fi

Bukan CI/CD pipeline enterprise. Tapi 25 baris yang ngurangin 15 menit manual jadi 1 command + 10 detik verify. Value dari automasi gak harus sophisticated. Value-nya consistency.

Report generation. Gue tiap Jumat musti bikin report "apa yang gue kerjakan minggu ini." Dulunya gue scan git log, copy paste commit messages, format manual. 20 menit. Sekarang:

#!/bin/bash
weekly-report.sh - generate weekly summary dari git log

SINCE=$(date -d 'last monday' +%Y-%m-%d 2>/dev/null || date -v -mon +%Y-%m-%d)
PROJECTS=("$HOME/dev/blog" "$HOME/dev/api" "$HOME/dev/scripts")

echo "# Weekly Report - $(date +'%Y-%m-%d')"
echo ""

for proj in "${PROJECTS[@]}"; do
if [ -d "$proj/.git" ]; then
commits=$(cd $proj && git log --since="$SINCE" --oneline --author="$(git config user.email)" 2>/dev/null)
if [ -n "$commits" ]; then
echo "## $(basename $proj)"
echo "$commits" | sed 's/^/- /'
echo ""
fi
fi
done

5 menit bikin script. 20 menit manual jadi 5 detik. Tiap Jumat. ROI luar biasa.

---

Shell Script vs Python vs Makefile: Kapan Pakai Apa

Bukan soal "yang terbaik." Soal kompleksitas tugas:

Shell script (bash/zsh). Untuk: file operations, system commands, chaining CLI tools. Glue language buat hal yang lo udah lakuin di terminal. Contoh: bootstrap project, deploy script, log parsing.

Shell menang kalau: lo cuma chaining command yang udah ada
git log --since="1 week ago" --pretty=format:"%h %s" | grep "fix:" | wc -l

Python. Untuk: logic complex, data processing, API calls, conditional yang ribet. Kalau script lo mulai 100+ baris bash dengan nested if, pindah ke Python. Lebih readable, lebih maintainable.

Python menang kalau: ada logic kompleks
import subprocess, json, requests
from datetime import datetime, timedelta

since = (datetime.now() - timedelta(days=7)).isoformat()
repos = ["blog", "api", "scripts"]

for repo in repos:
log = subprocess.run(
["git", "-C", f"~/dev/{repo}", "log", "--since", since, "--pretty=format:%h %s"],
capture_output=True, text=True
)
commits = log.stdout.strip().split("\n") if log.stdout.strip() else []
fix_commits = [c for c in commits if "fix:" in c]
print(f"{repo}: {len(fix_commits)} fixes this week")

Makefile. Untuk: project-specific tasks yang dipake tim. make test, make build, make deploy. Declarative, standard, tiap dev tau make .

Makefile - project tasks
.PHONY: test build deploy lint

test:
npm test

build:
npm run build

deploy: test build
./scripts/deploy.sh production

lint:
npx eslint src/ --fix

Bukan "Makefile lebih powerful." Makefile punya tempatnya: project tasks yang dipake orang lain. Kalau script cuma lo pake sendiri, shell script cukup. Kalau tim pake, Makefile bikin standard interface.

Filosofi: pilih tool sesuai kompleksitas, bukan sesuai hype. Gue pernah liat orang bikin 5 baris bash dibungkus Python 50 baris "biar typed." Over-engineer. Gue juga pernah liat 500 baris bash yang musti pake Python tapi dipertahanin "biar gak install Python." Wrong trade-off.

---

Yang Gak Gue Automasi

Bukan semua harus diautomasi. Yang gue hindari:

One-off tasks. Script one-time migration? Kalau lo cuma jalanin sekali, nulis script mungkin lebih lama dari manual. Kecuali kalau task high-risk dan script bikin safer (atomic transaction, rollback).

Things that change every time. Kalau task-nya beda tiap kali (deploy ke client baru dengan setup beda), automasi = brittle. Lo spent lebih banyak waktu maintain script daripada waktu yang dihemat. Better: document checklist, lakuin manual.

Things that need human judgment. Code review, merge conflict resolution, architecture decisions. Tools bisa bantu (linting, formatting, test), tapi keputusan tetap human. Jangan automasi yang butuh taste.

Experimental workflow. Lo belum tau workflow yang bener. Automasi early = lock-in ke workflow yang mungkin salah. Stabilkan dulu workflow-nya, baru automasi.

---

Yang Gue Pelajarin Soal Mindset

Automasi itu bukan soal "bisa bash scripting." Banyak dev yang bisa bash, tapi gak pernah automasi apa-apa. Mindset-nya yang beda:

Noticing friction. Saat lo ngelakuin hal yang ribet, respon default gue dulu: "ya gitu emang caranya." Sekarang: "ini ribet, musti ada cara yang lebih cepet." Friction itu sinyal, bukan normal.

Quantifying time. "Cuma 5 menit" kelihatannya kecil. Tapi 5 menit * 5 kali seminggu * 52 minggu = 21.6 jam setahun. Setengah hari kerja, ilang. Tiap "kecil" yang diulang = besar dalam long-term.

Investment vs expense. 1 jam bikin script = expense sekarang. Tapi script itu jalan 100x setahun = 100x return. Automasi itu investment yang compound. Beda dengan nonton Netflix (expense yang gak compound).

Default to automation. Sekarang tiap gue ngelakuin hal yang sama 2x, alarm bunyi di kepala gue: "automasi." Bukan "nanti aja." Bukan "sekarang lagi sibuk." Sekarang. 2x = sinyal, jangan tunggu 10x.

---

Yang Sering Disalahpahami

"Automasi cuma buat DevOps." - Salah. Frontend dev yang pake script buat generate component boilerplate? Itu automasi. Backend dev yang bikin seed data script? Itu automasi. Dev mobile yang bikin script buat screenshot store listing? Automasi. Semua dev punya repetitive tasks, semua dev benefit dari automasi.

"Lo musti pake tool sophisticated (Ansible, Terraform, etc)." - Gak. Shell script 20 baris udah solve 80% problem. Tool sophisticated buat infrastructure-as-code itu bukan starting point, itu endpoint kalau lo manage 100 server.

"Automasi bikin lo lupa cara manual." - Betul, dan itu feature, bukan bug. Lo gak harus inget 20 step deploy. Lo harus inget 1 command. Otak lo buat hal yang lebih penting.

"Bikin script itu ribet." - 20 baris bash = 5 menit nulis. 5 menit vs 18 jam setahun. Kalau lo bilang "ribet," lo gak ngitung math-nya.

---

Penutup yang Jujur

Automasi itu gak soal tool. Gue pake shell script buat 90% case, Python buat yang complex, Makefile buat project tasks. Tool-nya gak penting. Yang penting: mindset sadar friction, dan instinct buat bilang "ini musti di-automasi."

Filosofi yang gue pelajarin: "if you do it twice, automate it." Bukan karena gue malas. Karena waktu gue lebih berharga buat hal yang butuh human judgment - design, architecture, code review. Bukan buat ngulang 20 step yang sama 100x.

Kalau lo belum pernah nulis script buat automasi hal apapun, coba mulai dari 1 hal yang lo lakuin manual tiap minggu. Deploy, report, setup, apapun. 5 menit nulis bash script, return compound selamanya. Saat lo jalanin pertama kali dan sadar "wah, ini tinggal 1 command," lo bakal ngerasa "ah, gitu toh." Moment itu yang ngubah cara lo liat repetitive work.

Gue masih automasi hal baru tiap minggu. Tiap nemu friction, tanya "ini bisa di-automasi gak?" 80% jawabannya iya. 20% jawabannya "gak, ini butuh judgment." Automasi yang 80%, fokus ke 20% yang butuh otak lo.