{"id":196140,"date":"2025-04-21T07:03:59","date_gmt":"2025-04-21T07:03:59","guid":{"rendered":"https:\/\/peraltafinancing.com\/analytics\/i-tried-to-build-image-captioning-app-with-openai-codex-cli\/"},"modified":"2025-04-21T07:03:59","modified_gmt":"2025-04-21T07:03:59","slug":"i-tried-to-build-image-captioning-app-with-openai-codex-cli","status":"publish","type":"post","link":"https:\/\/fivemor.com\/?p=196140","title":{"rendered":"I Tried to Build Image Captioning App With OpenAI Codex CLI"},"content":{"rendered":"


\n<\/p>\n

\n

OpenAI Codex CLI is an open\u2011source command-line tool that brings the power of OpenAI\u2019s latest reasoning models directly to your terminal. Think of it as a lightweight AI coding assistant that lives in your shell<\/em>: it can read your code, modify files, and even execute commands in your project environment. This means you can ask it to build features, fix bugs, or explain unfamiliar code without leaving your development workflow. In short, it\u2019s chat-driven development<\/em> \u2013 you interact with Codex in natural language and it responds with code edits or command results, effectively giving you ChatGPT-level reasoning plus the ability to run code and see outcomes in real-time\u200b. Sounds intriguing, right? Further in this article, I will tell you about how to access it and use for your queries.<\/p>\n

Key Features of OpenAI Codex CLI<\/h2>\n

OpenAI Codex CLI comes with several powerful features that make it a handy companion for developers. One of the biggest advantages of Codex CLI is that it runs entirely on your local machine. Your source code and files stay in your environment and aren\u2019t uploaded wholesale to a cloud service\u200b. Only your prompts and high-level context (like summarized diffs or relevant snippets) are sent to the OpenAI API for generating responses\u200b. Because the CLI is open-source and works locally, it gives you privacy and control by design \u2013 your workflow and code remain private. This makes Codex CLI especially appealing for codebases that you can\u2019t or don\u2019t want to share, while still leveraging powerful AI assistance.<\/p>\n

By integrating directly into the terminal, Codex CLI fits naturally into a developer\u2019s day-to-day work. You can chat with the AI assistant right next to your git commands, text editor, and build tools, which means less context-switching compared to using a separate chat interface. The tool is designed for quick iteration: ask a question or give an instruction, let it propose or apply a change, run the code, and repeat \u2013 all in one place\u200b.<\/p>\n

Here are some of the highlights:<\/p>\n

1. Zero-Setup Installation<\/h3>\n

Codex CLI is extremely easy to get running. All you need is Node.js and an OpenAI API key<\/a> \u2013 a single command like npm install -g @openai\/codex installs the CLI globally, with no other setup required\u200b. There\u2019s no complex configuration or environment fiddling; bring your API key and it \u201cjust works\u201d\u200b. (You can even update to the latest version at any time with a simple codex \u2013upgrade command\u200b.)<\/p>\n

2. Terminal-Native Design<\/h3>\n

Codex runs entirely in your terminal, so it feels like a natural extension of your shell environment\u200b. You can invoke it from your project directory and have it interact with your local files and tools. This terminal-native approach means you don\u2019t have to switch to a browser or GUI \u2013 perfect for maintaining flow and context while coding\u200b. The CLI provides an interactive chat-like interface in text, so you see the AI\u2019s responses (like code diffs or command outputs) right in the console.<\/p>\n

3. Multimodal Inputs<\/h3>\n

Unlike plain text-only tools, Codex CLI accepts multimodal inputs \u2013 you can pass not just text prompts, but also images such as screenshots or diagrams to guide the assistant\u200b. For example, you could drag a screenshot of an error message or a UI sketch into the terminal, and Codex can interpret it and act on it. This is a unique capability that lets the AI use visual information to generate or edit code accordingly\u200b. Under the hood, it uses vision-enabled models to understand images, enabling use cases like debugging from a screenshot of a stack trace or building a layout from a wireframe.<\/p>\n

4. Rich Approvals Workflow<\/h3>\n

Codex CLI gives you fine-grained control over what it can do autonomously through a rich approval system. You can choose between three modes (Suggest, Auto Edit, Full Auto) that determine whether the AI\u2019s proposed code changes or commands are auto-executed or require your confirmation\u200b. This flexible workflow lets you decide how hands-on you want to be: you can start conservatively (manual approvals for everything) and dial up to full automation for repetitive tasks. We\u2019ll dive deeper into these modes in the next section, but the key point is that Codex won\u2019t make changes you\u2019re uncomfortable with \u2013 you\u2019re always in charge of approvals.<\/p>\n

5. Local Execution and Privacy<\/h3>\n

All code execution and file editing happens on your<\/em> machine, within your project\u2019s environment. Aside from the model queries, nothing is sent out \u2013 the CLI doesn\u2019t upload your codebase to OpenAI<\/a>. This means you retain complete privacy. You can safely use Codex CLI on proprietary or sensitive code knowing that the tool isn\u2019t retaining or sharing your data. Even when using the most autonomous mode, Codex runs in a sandboxed environment with no network access, ensuring any actions it takes stay local to your system\u200b. In short, you get the benefits of an AI pair programmer without giving up privacy or security.<\/p>\n

Codex CLI Modes that You Must Know<\/h2>\n

Github Link: openai\/codex<\/a><\/p>\n

A standout feature of Codex CLI is its approval workflow \u2013 essentially, you decide how much freedom the AI has to make changes or run commands. There are three approval modes: Suggest, Auto Edit, and Full Auto. Each mode strikes a different balance between automation and user oversight, so you can pick what fits your comfort level for the task at hand\u200b. Here\u2019s an overview of how they work:<\/p>\n

1. Suggest Mode (Default)<\/h3>\n

This is the most conservative mode, ideal for when you want to carefully review everything. The AI can read your project files and suggest<\/em> code edits or terminal commands, but it won\u2019t apply changes or execute anything without your explicit approval\u200b <\/a>. Essentially, Codex will interact with you like an expert advisor: it might propose a patch diff for a bug fix or show a shell command to run tests, and then ask for your confirmation. Use Suggest mode for safe exploration \u2013 e.g. learning a new codebase or doing a code review \u2013 where you want to see recommendations but apply them manually\u200b <\/a>.<\/p>\n

2. Auto Edit Mode<\/h3>\n

In Auto Edit, Codex is allowed to automatically apply code changes (it can edit\/write to files on its own) but still must ask before running any shell commands\u200b <\/a>. This mode is great for tasks like refactoring or making repetitive edits across a codebase. You get the efficiency of the AI directly modifying code for you, while retaining a checkpoint of control before any program execution. For example, Codex might rewrite a function in multiple files and save the changes immediately, but if it wants to run your test suite or start the dev server, it will pause and ask for your go-ahead. Auto Edit mode is a balance: faster coding iterations, yet you still supervise side-effects like commands\u200b <\/a>.<\/p>\n

3. Full Auto Mode<\/h3>\n

Full Auto gives the AI the most autonomy. Codex can read and write files and also execute shell commands on its own without stopping for approval\u200b <\/a>. In this mode, it becomes a truly automatic agent \u2013 you could ask it to perform a complex task and then sit back while it works through the steps. To keep things safe, Full Auto runs in a restricted sandbox: all commands are executed with network access disabled and scoped to your project directory (it can\u2019t wander outside or access the internet)\u200b. This mode is ideal for longer tasks where you trust the AI to iterate, for instance, fixing a broken build or prototyping a new feature while you take a short break\u200b <\/a>. Of course, you should use Full Auto with caution \u2013 it\u2019s powerful, but you\u2019ll want to ensure you\u2019ve backed up or version-controlled your code (the CLI will actually warn you if you\u2019re not in a git repo when starting Auto Edit or Full Auto)\u200b\u200b <\/a>.<\/p>\n

Comparison of Modes<\/h3>\n

The differences between the three modes are summarized in the table below, along with typical use cases for each:<\/p>\n

\n\n\n\n\n\n\n
Mode<\/strong><\/td>\nWhat the Agent Can Do<\/strong><\/td>\nWhen to Use (Use Cases)<\/strong><\/td>\n<\/tr>\n
Suggest<\/strong> (default)<\/td>\n\u2013 Read any files in your repo
– Propose edits and shell commands (requires your approval to apply\/execute)\u200b\u00a0<\/a><\/td>\n		Safe exploration of codebases, code reviews, learning a new project\u2019s structure where you want full control over changes\u200b <\/a>.<\/td>\n<\/tr>\n
Auto Edit<\/strong><\/td>\n\u2013 Read and modify<\/em> files (apply edits automatically)
– Propose shell commands (execution still requires approval)\u200b\u00a0<\/a><\/td>\n		Refactoring code or making bulk edits while keeping an eye on side effects. Great for repetitive changes where manual file editing is tedious but you still want to approve any commands\u200b <\/a>.<\/td>\n<\/tr>\n
Full Auto<\/strong><\/td>\n\u2013 Read, write, and execute commands autonomously (all actions auto-approved)
– Runs in sandbox (no network, confined to project directory)\u200b\u00a0<\/a><\/td>\n		Large or time-consuming tasks like fixing all tests in a broken build or scaffolding a new app from scratch. Useful when you want to delegate execution entirely to the AI (e.g. quick prototyping)\u200b <\/a>.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n

In practice, you can select the mode that makes sense for your situation. By default, if you just run codex it starts in Suggest mode. To explicitly choose a mode, you can launch the CLI with a flag: for example, use \u2013auto-edit or \u2013full-auto to start in those modes\u200b <\/a>. There\u2019s also an interactive command (\/mode) to toggle modes during a session\u200b <\/a>. This way, you might begin in Suggest mode to see what Codex plans to do, then switch to Auto Edit once you\u2019re comfortable with its suggestions, and maybe kick into Full Auto for the final stretch of a task. The important thing is that you<\/em> control the level of autonomy at all times.<\/p>\n

System Requirements for Codex CLI<\/h2>\n

Before installing Codex CLI, make sure your development environment meets the minimum requirements. The tool is cross-platform, but currently works best on Unix-like systems. Here are the minimum and recommended specs:<\/p>\n

\n\n\n\n\n\n\n\n
Requirement<\/strong><\/td>\nMinimum<\/strong><\/td>\nRecommended<\/strong><\/td>\n<\/tr>\n
Operating System<\/strong><\/td>\nmacOS 12+ or Ubuntu 20.04+\/Debian 10+ (Linux)\uff1b Windows 11 via WSL2<\/td>\nLatest OS updates (latest macOS or LTS Linux release; Windows with latest WSL2) for best compatibility.<\/td>\n<\/tr>\n
Node.js<\/strong><\/td>\n22 (or newer)\u200b<\/td>\nLatest LTS version of Node.js (>= 22) for stability.<\/td>\n<\/tr>\n
Git<\/strong> (optional)<\/td>\n2.23+ (if using version control features)\u200b<\/td>\nNewest Git available (optional, but recommended for full functionality like PR helpers).<\/td>\n<\/tr>\n
Memory (RAM)<\/strong><\/td>\n4 GB minimum<\/td>\n8 GB or more (for smoother performance on large tasks)\u200b.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n

Codex CLI has been tested on macOS and Linux. Windows users can run it via WSL2 (Windows Subsystem for Linux) since native Windows support is still experimental\u200b <\/a>. You\u2019ll also need an OpenAI API key (from your OpenAI account) to authenticate the CLI \u2013 we\u2019ll cover that next. Aside from these, no other special hardware is required; if you can run modern Node.js, you\u2019re likely good to go.<\/p>\n

Note:<\/em> It\u2019s recommended to have your project under source control (git) when using Codex CLI, especially for Auto modes. While Git isn\u2019t strictly required to run the CLI, having version control will allow you to easily review changes and rollback if needed. In fact, Codex will remind you with a warning if you try to use Auto Edit or Full Auto in a directory that\u2019s not a git repo\u200b<\/p>\n

How to Use OpenAI Codex CLI?<\/h2>\n

Step 1: Install Node.js<\/h3>\n
\"\"<\/figure>\n
    \n
  1. Download Node.js v22+ from nodejs.org<\/a>.<\/li>\n
  2. Install using default settings.<\/li>\n
  3. Verify installation:<\/li>\n<\/ol>\n
    bash\nnode --version\u00a0 # Should show v22+<\/em>\nnpm --version \u00a0 # Should show v10<\/em><\/code><\/pre>\n
    Step 2: Install Codex CLI<\/h3>\n
    \"\"<\/figure>\n
    bash\nnpm install -g @openai\/codex<\/code><\/pre>\n