---

Software engineering has always evolved alongside its tools. Compilers turned human ideas into executable programs. Integrated development environments improved productivity and debugging. Version control systems enabled collaboration at scale. Continuous delivery pipelines made rapid and reliable deployment possible.

In early 2026, another major step appeared: agentic coding systems capable of participating in the engineering process itself.

---

One of the most advanced examples of this new class of tools is GPT-5.3-Codex, OpenAI’s latest coding-focused model designed to reason across repositories, plan multi-step changes, execute development tasks, and collaborate with engineers across the full software lifecycle.

Unlike traditional autocomplete-style coding assistants, GPT-5.3-Codex is capable of operating across entire workflows: scaffolding projects, editing multiple files, generating diffs, interacting with terminal commands, and assisting in code review or refactoring tasks.

This article walks through a realistic development scenario using Codex from the command line — illustrating how an agentic coding system can participate in building a modern data-driven web application.

Beginning the Journey: Launching Codex

The process begins in a terminal.

The developer installs the Codex CLI and launches it inside a working directory.

npm install -g @openai/codex
mkdir poddata
cd poddata
codex

(Alternatively, Codex can be invoked without installation using npx @openai/codex.)

Once started, the CLI connects to the gpt-5.3-codex model and begins operating within the current workspace.

The Codex sandbox is a controlled execution environment where the Codex agent can safely read files, generate code, and run commands while limiting what it can access on your system. Think of it as a temporary “mini computer” or container that Codex uses to perform coding tasks without risking your machine or infrastructure.

You can change the model and effort by using the /model command:

The developer, then, can issue a high-level request:

Create a React project that analyses podcast metrics from data/data.csv, using D3 to build several charts.

Instead of producing a single snippet of code, Codex analyses the request in the context of the workspace and begins incrementally constructing the project. If it doesn’t find the specified data.csv file, it creates a sample one.

The terminal displays the actions it performs. When finished, it asks permission to install dependencies:

It then attempts to run the project for verification:

Finally, a summary is presented:

Results may vary widely, due to the nature of LLMs:

If the project is not yet under version control, initializing Git is recommended so Codex can produce structured diffs during future iterations:

git init
git add .
git commit -m "Initial scaffold"

You might run into the following error:

This comes from Git’s security feature introduced after the CVE-2022-24765 vulnerability. Git refuses to operate on repositories whose ownership differs from the current user, because this could allow a malicious repo to execute hooks or config under another user.

This happens frequently when:

• using containers / sandboxes
• using WSL
• using Docker volumes
• running tools like Codex CLI
• accessing repos created by another user or root
• mounting drives from another OS

The solution is in the error message itself and marks this repository as safe.

Creating a git repository is a simple step that dramatically improves the agent’s ability to reason about code changes.

Static Diffs and Multi-File Refactoring

A major strength of agentic coding systems is the ability to modify multiple files simultaneously.

For example, suppose the developer requests:

Add zoom and pan behaviour to the charts.

Codex analyses the existing chart components and introduces a reusable utility.

The resulting diff might look like this:

And the final summary:

Visual Editing and Multimodal Context

When Codex is used within environments that support multimodal inputs — such as IDE integrations or visual interfaces — it can incorporate annotated screenshots into its reasoning process.

For example, imagine the dashboard contains an introductory paragraph that the developer wants removed. An annotated screenshot pointing to the text may produce a patch like this:

--- a/src/App.jsx
+++ b/src/App.jsx
@@ -8,9 +8,6 @@ export default function App() {

     <div className="container">

       <h1>Podcast Metrics Dashboard</h1>

-      <p className="intro">
-        This dashboard explores episode performance and guest behavior.
-      </p>

       <Charts />

     </div>

This workflow illustrates how modern coding agents can bridge visual design feedback and source code modifications.

Feature Development: Search by Guest

To explore a full feature lifecycle, the developer asks Codex to implement a guest search filter. Codex goes to work:

Once implemented, the system rebuilds and the dashboard now filters charts dynamically based on the selected guest. In real development environments, Codex can assist with generating diffs, running builds, and suggesting improvements such as input debouncing for large datasets.

Parallel Implementations and Experimentation

In cloud-based development pipelines, agentic systems can be used to generate multiple candidate implementations of a feature.

For example, when adding tooltip interactions to charts, two implementations might be explored: a simple static tooltip component and a dynamic cursor-tracking tooltip approach using a useTooltip hook. Developers can evaluate these alternatives in preview environments before selecting the preferred implementation.

This workflow transforms feature development from a single-attempt process into iterative experimentation.

Code Review and Collaboration

Agentic models can also assist during code review. When examining a pull request, Codex may analyze diffs and flag potential issues.

For example:

The SVG overlay used for zoom interaction appears above the chart elements and may intercept pointer events, preventing hover detection. Consider adjusting element ordering or pointer-events settings.

These types of observations mirror issues often caught during human code reviews. The difference is that the analysis can occur immediately after changes are generated, helping developers identify problems earlier in the workflow.

The Emergence of an Engineering Partner

Across the scenarios described in this article — scaffolding projects, generating visualization components, performing multi-file refactoring, integrating UI feedback, and assisting with review — one theme becomes clear: modern coding systems like GPT-5.3-Codex do not simply generate snippets of code. They participate in the engineering process itself.

The developer remains the architect and decision-maker, but the agent becomes a powerful collaborator capable of analysing repository context, generating structured diffs, coordinating multi-file changes, assisting with debugging and review, and accelerating experimentation.

For many years, AI coding tools were judged primarily by the quality of individual code suggestions. Today the bar is higher.

The new question is not:

Can an AI write code?

The real question is:

Can it participate meaningfully in the engineering workflow?

GPT-5.3-Codex represents a step toward that future. By combining reasoning, repository awareness, and tool interaction, it moves beyond simple autocomplete and toward a model that can collaborate with developers throughout the lifecycle of software creation.

The result is not automation replacing engineers — but a new kind of human-agent engineering partnership.