Automate Dev Workflows with Codex Scripts
Automating Workflows with Codex and Scripts: A Practical Tutorial
Codex-style coding agents become much more useful when you stop treating them as chat tools and start wiring them into repeatable scripts. With a few small shell or Node.js commands, you can automate code review, test generation, changelog drafting, refactoring suggestions, and documentation updates. This tutorial shows a practical workflow using Codex-compatible tooling, OpenAI SDK patterns, and 59API as a low-cost API relay.
59API is useful here because it provides cheap, pay-as-you-go access to GPT models and Claude models such as Opus, Sonnet, Haiku, and Fable through a compatible API base URL: https://api.59api.com. It works with Claude Code, Codex, and standard OpenAI SDK clients, so you can build automation without locking yourself into one model provider. The models are native official-quality models, not downgraded substitutes, which matters when your scripts are making decisions about code.
Step 1: Choose the Workflow to Automate
Start with one task that is frequent, rule-based, and annoying enough to justify automation. Good candidates include summarizing pull request diffs, finding risky code changes, generating tests for modified files, converting TODO comments into tickets, or producing release notes from commits. Avoid automating broad architecture decisions at first. The best early automation gives you a draft, warning, or checklist that a developer can verify.
For this tutorial, we will automate a pull request assistant that reads a Git diff, asks a Codex-compatible model to identify risks, suggests tests, and writes a short review summary. You can run it locally before opening a PR or inside CI.
Step 2: Set Environment Variables
Store your API key outside the script. In your terminal or CI secrets, set OPENAI_API_KEY to your 59API key and OPENAI_BASE_URL to https://api.59api.com. Most OpenAI-compatible SDKs and Codex-related tools can use these values directly or with minimal configuration.
- OPENAI_API_KEY: Your 59API key.
- OPENAI_BASE_URL: https://api.59api.com
- MODEL: Choose a coding-capable GPT or Claude model depending on cost and quality needs.
For routine automation, use a faster, cheaper model for summaries and lint-like feedback. Reserve stronger models such as top Claude or GPT options for complex refactors, security analysis, or multi-file reasoning. This is where 59API’s low-cost relay model is helpful: you can run more automation without turning every CI job into a budget problem. If you have not created an account yet, you can sign up for 59API and start with pay-as-you-go usage, then share your referral link later for rebate benefits.
Step 3: Create a Review Prompt That Is Specific
Your script is only as reliable as its prompt. Do not ask the model to “review this code” in a vague way. Give it a role, input format, output structure, and limits. For example, instruct it to review only the provided diff, avoid inventing files, rank issues by severity, and include test suggestions. Ask for concise output so your CI logs remain readable.
A strong prompt might say: You are a senior engineer reviewing a pull request diff. Identify bugs, missing tests, security risks, performance regressions, and unclear code. If there are no serious issues, say so. Return sections named Summary, Risks, Suggested Tests, and Questions. Only discuss evidence visible in the diff.
Step 4: Write a Script Around Git Diff
Create a small script that captures the diff and sends it to the model. In Node.js, you can use child_process to run git diff --staged or git diff origin/main...HEAD, then pass the result to the OpenAI SDK client configured with baseURL: process.env.OPENAI_BASE_URL. In Python, use subprocess to collect the diff and the OpenAI-compatible client with the same base URL.
Keep the script defensive. If the diff is empty, exit early. If the diff is huge, either reject it with a helpful message or split it by file. Large diffs can exceed context limits, cost more, and produce lower-quality reviews. A good pattern is to review each changed file independently, then run a second summarization pass over the file-level findings.
Step 5: Add Guardrails for Cost and Quality
Automation should be predictable. Add a maximum character count before calling the API. Print which model is being used. Set a reasonable timeout. Cache results based on commit hash if your CI jobs rerun often. For output quality, require a structured format and fail softly: the script should warn developers, not block merges, until you trust it.
- Cost control: Skip generated files, lockfiles, vendor folders, and minified assets.
- Accuracy: Tell the model to cite file names and changed behavior from the diff.
- Safety: Never send secrets, .env files, private keys, or production credentials.
- Reliability: Start in advisory mode before making CI checks required.
Step 6: Turn It into a Reusable Command
Add a package script such as ai:review that runs your automation locally. Developers can then execute one command before pushing. You can also add ai:tests to ask the model for missing test cases, ai:docs to draft README updates from changed public APIs, or ai:release to summarize commits since the last tag.
The key is to make each command narrow. A script that reviews a diff is easier to trust than a script that reviews, rewrites, commits, and pushes all at once. If you do allow automated edits, require a clean working tree first and show the patch before applying it.
Step 7: Run the Same Script in CI
Once the local command is useful, add it to GitHub Actions, GitLab CI, or your preferred pipeline. Store the 59API key as a secret, set the base URL, install dependencies, and run the script against the PR diff. You can post the result as a job summary, PR comment, or artifact.
A practical CI setup runs on pull requests, excludes documentation-only changes if desired, and never fails the build on the first rollout. After your team sees consistent value, you can make specific checks stricter, such as blocking when the model finds likely secret exposure or missing migration tests.
Step 8: Expand to Claude Code and Codex Workflows
Because 59API is compatible with Claude Code, Codex, and OpenAI SDK clients, you can mix tools without changing your billing strategy. For example, use a fast GPT model for commit summaries, Claude Sonnet for deeper code reasoning, and a lightweight model for documentation drafts. The same base URL keeps your scripts portable.
The biggest productivity gains come from chaining small automations: summarize the diff, identify risky files, generate targeted test ideas, then create a release note draft. Each step stays reviewable, and developers remain in control. With Codex-style agents, scripts, and a low-cost relay like 59API, AI becomes part of your engineering workflow rather than another tab to check.