Core Build: 5 Automation Scripts

Script #2: Text Analysis Automation (10 min)

Core concept: Send text to AI API for analysis and receive structured insights.

Real-world applications:

• Economics: Analyze research paper abstracts for methodology and findings
• Software: Generate code review summaries from pull request descriptions
• Business: Extract sentiment and themes from customer feedback

Pattern demonstration:

# Input → AI Processing → Output pattern
curl -X POST $API_ENDPOINT \
  -H "x-api-key: $API_KEY" \
  -d "{\"prompt\": \"Analyze: $INPUT\"}"

Key concepts:

• Command-line argument handling
• Multi-line prompt engineering
• JSON response parsing with jq
• Error handling for API failures

Create scripts/analyze.sh and implement the three-part pattern. Test with a sample research abstract or business email.

Success criteria:

Run the script with sample text and receive structured analysis output (key points, sentiment, recommendations).

Script #3: Data Transformation Pipeline (10 min)

Core concept: Process data files through AI-guided transformation, validation, and enrichment.

Real-world applications:

• Data cleaning: Fix inconsistent date formats, validate entries
• Format conversion: Transform JSON to CSV with AI-guided field mapping
• Data enrichment: Add categories, tags, or summaries to existing records

Pipeline pattern demonstration:

# File processing pipeline pattern
cat input.csv | \
  python3 -c "import sys; [process with AI]" | \
  tee output.csv

Key concepts:

• Unix pipe composition (stdin/stdout)
• File format detection and parsing
• Batch processing for large datasets
• Preserving original data during transformation

Create scripts/transform.sh that reads a data file, sends records to AI for processing, and outputs transformed results.

Success criteria:

Process a sample CSV file and generate cleaned, enriched output with AI-added insights.

Script #4: Integration Automation (10 min)

Core concept: Connect multiple APIs and services in a single automated workflow.

Real-world applications:

• Research automation: Pull papers from arXiv, summarize with AI, save to Notion
• Monitoring: Fetch metrics from analytics API, analyze trends, send Slack alerts
• Data sync: Read from source API, transform with AI, write to destination database

Integration pattern demonstration:

# Multi-API orchestration pattern
curl $SOURCE_API | jq '.data' | \
  ./ai-process.sh | \
  curl -X POST $DEST_API -d @-

Key concepts:

• API authentication for multiple services
• Data format translation between systems
• Error recovery and retry logic
• Logging for debugging complex integrations

Create scripts/integrate.sh that demonstrates fetching, processing, and pushing data across service boundaries.

Success criteria:

Successfully retrieve data from one API, process with AI, and deliver to another service with proper error handling.

Script #5: Workflow Orchestration (10 min)

Core concept: Chain multiple scripts together with conditional logic and error handling.

Real-world applications:

• Daily research digest: Fetch papers, summarize, analyze, email report
• Content pipeline: Generate draft, review with AI, format, publish
• Data processing workflow: Extract, validate, transform, load with quality checks

Orchestration pattern demonstration:

# Conditional workflow execution
./fetch.sh && \
  ./process.sh || \
  ./handle-error.sh

Key concepts:

• Script exit codes and error propagation
• Conditional execution with && and ||
• State management across script steps
• Rollback and recovery mechanisms

Create scripts/orchestrate.sh that coordinates the previous four scripts in a meaningful workflow relevant to your domain.

Success criteria:

Execute a multi-step workflow that demonstrates proper error handling, conditional logic, and successful completion across all stages.

Library Organization (10 min)

Create the toolkit structure:

Transform individual scripts into an organized, maintainable library. This structure makes scripts discoverable and reusable across projects.

Directory structure:

automation-toolkit/
├── scripts/
│   ├── summarize.sh      # Script #1 from Quick Start
│   ├── analyze.sh        # Script #2: Text analysis
│   ├── transform.sh      # Script #3: Data pipeline
│   ├── integrate.sh      # Script #4: API integration
│   └── orchestrate.sh    # Script #5: Workflow
├── lib/
│   └── common.sh         # Shared functions
├── config/
│   ├── .env.example      # Template for secrets
│   └── .gitignore        # Protect sensitive files
└── README.md             # Usage documentation

Shared library pattern:

Extract common functionality into lib/common.sh:

# Reusable API call function
call_ai_api() {
  curl -X POST $API_ENDPOINT \
    -H "x-api-key: $API_KEY"
}

Organization benefits:

Move all scripts into scripts/ directory, create lib/common.sh for shared functions, and document usage in README.md.