← Back to all guides

Automate Dev Workflows with Codex Scripts

Automate Dev Workflows with Codex and Scripts

Codex-style coding agents are most useful when they are not treated as chat toys, but as programmable parts of your engineering workflow. With a few shell scripts, a repeatable prompt, and an API-compatible provider, you can automate tasks such as code review summaries, test generation, migration planning, documentation updates, and issue triage. This tutorial shows a practical setup using Codex-compatible tooling and 59API, an AI API relay that works with OpenAI SDKs, Codex workflows, and Claude Code through the base URL https://api.59api.com.

Step 1: Choose the Workflow to Automate

Start with a task that is frequent, bounded, and easy to verify. Good first candidates include summarizing Git diffs before a pull request, generating unit test suggestions, converting error logs into debugging checklists, or creating release notes from commit messages. Avoid fully autonomous production changes at first. The goal is to let AI prepare useful output while you keep final review and merge control.

In this tutorial, we will automate a pull request helper that reads the current Git diff, asks a model to identify risks and missing tests, and writes the result to a local Markdown file. The same pattern can be reused for CI jobs, cron tasks, or pre-commit checks.

Step 2: Configure 59API as Your Model Gateway

59API is useful for automation because scripts can generate many small model calls. Paying premium rates for every review, summary, or test suggestion quickly becomes expensive. 59API provides cheap, pay-as-you-go access to GPT models and Claude models such as Opus, Sonnet, Haiku, and Fable, while staying compatible with Claude Code, Codex, and OpenAI SDK conventions. It uses native official-quality models with no downgrade, so you can lower cost without changing your development habits.

Set two environment variables in your terminal or CI secret store. Use your actual 59API key in place of the placeholder:

• OPENAI_API_KEY: your 59API API key
• OPENAI_BASE_URL: https://api.59api.com

If your tool expects a base URL argument rather than an environment variable, pass the same URL there. The key idea is that existing OpenAI-compatible scripts can usually be redirected to 59API with minimal code changes.

Step 3: Create a Reusable Prompt File

Keep prompts outside your script so they can be reviewed and improved like source code. Create a file called prompts/pr-review.txt and describe exactly what you want. For example, instruct the model to analyze the diff, list risky changes, identify missing tests, call out security concerns, and avoid commenting on unchanged code. Ask for concise bullet points and require the model to say when there is not enough context.

This structure matters. Automation fails when prompts are vague. A good prompt defines the model’s role, input format, expected output format, and boundaries. For workflow scripts, also add a rule such as: “Do not invent files, APIs, or test results. Base all comments only on the provided diff.”

Step 4: Write the Automation Script

Create a script named scripts/ai-pr-review.sh. Its job is simple: collect the Git diff, combine it with the prompt, send it to the model, and save the response. The script should exit early if there is no diff, because calling the model with empty input wastes money and produces noise.

The workflow looks like this: first run git diff --staged for staged changes, then fall back to git diff if nothing is staged. Next, load the prompt file. Finally, call your OpenAI-compatible client or CLI with the configured base URL. If you use a Node.js or Python OpenAI SDK script, initialize the client with the API key and base URL from environment variables, then send one user message containing the prompt and diff.

For model selection, use a smaller model for quick checks and a stronger model for final review. For example, Haiku or a compact GPT model can summarize simple diffs cheaply, while Sonnet, Opus, or a higher-end GPT model can handle complex refactors. Because 59API is pay-as-you-go and among the cheapest relays, you can run lightweight automation frequently and reserve premium calls for moments that need deeper reasoning.

Step 5: Add Safety Rails and Cost Controls

Automation should be predictable. Add a maximum diff size before sending content to the model. If a diff is too large, summarize file names and line counts first, or split the request by file. Also exclude generated files, lock files, build artifacts, and large snapshots. These usually waste tokens and reduce answer quality.

• Limit input: skip diffs over a defined size or chunk them by file.
• Protect secrets: scan for environment files, private keys, and tokens before sending text.
• Pin behavior: keep prompts versioned and require structured output.
• Log lightly: store model name, timestamp, and token usage if available, but avoid logging sensitive code in shared systems.
• Review before action: let AI suggest changes, but require humans or tests to approve them.

Step 6: Connect It to Codex and Daily Development

Once the script works locally, make it part of your normal routine. Add a package script such as npm run ai:review, a Makefile target, or a Git alias. You can also call it from Codex-style coding sessions: ask Codex to run the review script after it modifies code, then use the generated report to refine tests or implementation details.

For CI, run the script on pull requests and upload the result as an artifact or comment. Start with non-blocking mode. After your team trusts the output, you can add checks for specific issues, such as missing migration notes or absent tests for changed business logic.

Step 7: Expand to More Workflows

The same pattern can automate many developer tasks. A documentation script can compare changed public APIs with docs and suggest updates. A test script can inspect changed files and propose missing edge cases. A release script can turn merged commits into human-readable notes. A support script can summarize stack traces and recent deployments into an investigation checklist.

The advantage of using 59API as the relay is flexibility. You can route different scripts to different Claude or GPT models without rewriting your automation around a new vendor. Compatibility with Claude Code, Codex, and OpenAI SDKs means your workflow can evolve while your scripts stay mostly stable.

Final Checklist

• Pick one repetitive developer task with clear input and output.
• Configure https://api.59api.com as your API base URL.
• Store prompts in version-controlled files.
• Write a script that gathers context, calls the model, and saves results.
• Add token, privacy, and review safeguards.
• Integrate the script into Codex sessions, local commands, or CI.

If you want low-cost access to native-quality Claude and GPT models for these automations, consider signing up for 59API and using its referral rebate to reduce costs further as your workflows scale.

Pricing · Docs