When many people first open Codex, they think of it as a more capable code-completion tool. If you do not program, it may seem unrelated to your work.

Codex is closer to an AI work agent that can read materials, execute steps, and deliver results. In an authorized workspace it can read files, analyze a project, run commands, create files, check results, and connect multiple steps into one task.

OpenAI’s Codex overview describes a workflow that starts with a goal, idea, or task: Codex gathers context, takes action, and produces a useful result. The official page lists desktop, web, CLI, IDE extension, and cloud entry points.

The key skill for an ordinary user is therefore not writing code. It is describing the task: where the input is, what the desired output should be, what must not happen, and how completion will be verified.

Here are nine useful ways to use Codex beyond writing code.

1. Organize files and materials on your computer

Download folders, project materials, meeting attachments, and old documents become messy quickly. You can ask Codex to scan names and contents, then generate a new directory structure according to rules.

For example:

Scan the PDFs, Word files, and images in this folder and classify them as contracts, invoices, resumes, learning materials, or other.
Do not delete the originals. Put classified copies in a sorted folder and create summary.md explaining why each file was classified that way.
Put uncertain files in a review folder instead of guessing.

It can:

  • create folders by year, project, or topic;
  • normalize file names;
  • find duplicates and likely duplicates;
  • identify empty, corrupted, or unreadable files;
  • generate a directory index.

When moving or renaming files, always ask for a preview first, keep the originals, and write output to a new directory.

2. Clean, merge, and analyze spreadsheets

Many office tasks do not require advanced software knowledge. The time is spent copying, pasting, and checking the same data repeatedly. Codex can process CSV, Excel, and other structured files for cleaning and merging.

For example:

Read every CSV in the data folder:
1. merge files with the same columns;
2. remove completely blank rows;
3. normalize dates to YYYY-MM-DD;
4. keep only the first 3 and last 4 digits of phone numbers and replace the middle with *;
5. sort by amount from high to low;
6. output cleaned.xlsx and a processing report.
Do not overwrite the originals.

Useful tasks include:

  • merging monthly sales sheets;
  • removing duplicate customers;
  • normalizing dates, amounts, and names;
  • creating pivot tables and summaries;
  • finding anomalies and missing values;
  • generating simple trend charts.

After delivery, sample-check several rows and ask Codex to report input rows, output rows, deleted rows, and records it could not process.

3. Turn scattered materials into a report

Place meeting notes, chat exports, task lists, email exports, and project documents in one workspace and ask Codex to create a structured report.

For example:

Read the materials in the meeting-notes, task-list, and risks folders and create weekly-report.md.
The report must contain:
- completed this week
- unfinished items
- risks and blockers
- decisions needed and who should make them
- next week's plan

Mark the source file after every conclusion. Do not turn information that is not in the materials into a fact.

This works particularly well for:

  • weekly and monthly reports;
  • project retrospectives;
  • meeting decision records;
  • first-pass screening of recruiting materials;
  • grouping customer feedback;
  • organizing course and reading notes.

The critical requirement is to preserve sources instead of asking for a summary that merely looks complete. A source-free summary is difficult to verify.

4. Rewrite and maintain content in batches

If you have product descriptions, FAQs, help documents, or social-media copy, Codex can rewrite and audit them against one style guide.

For example:

Rewrite the product descriptions in the docs folder:
- target developers who are new to APIs;
- answer what problem the user can solve at the beginning of each page;
- preserve every technical parameter and limitation;
- do not make exaggerated claims or invent examples;
- add one FAQ to each page;
- write results to a rewritten folder and create changes.md listing every change.

This can be used to:

  • turn technical explanations into user guides;
  • split long articles into newsletters, emails, and social posts;
  • standardize titles, terminology, and tone;
  • check typos, broken links, and stale information;
  • create first drafts in multiple languages.

Humans must review final copy involving a brand, law, pricing, or product promises.

5. Research options and prepare decisions

Codex does more than answer a question. In a project directory it can organize evidence, compare options, and produce a decision document.

For example:

Read the eight vendor documents in the research folder and create comparison.md.
Compare price, features, limitations, data retention, integration difficulty, and support.
Cite the source file and page after each conclusion. If documents contradict each other, list the conflict instead of choosing one version.
Finally classify options as suitable for small teams, suitable for enterprises, or requiring more confirmation. Do not make the final decision for me.

This is useful for:

  • comparing software before a purchase;
  • product and vendor research;
  • organizing travel or course plans;
  • comparing jobs and candidates;
  • archiving competitor material;
  • turning webpages, PDFs, and notes into a research brief.

If research requires the internet, ask Codex to record sources, access dates, and key quotations so unverified material does not silently become a conclusion.

6. Read images, PDFs, and screenshots

The OpenAI quickstart lists analyzing images and files as a core API use case. Images, uploaded files, and PDFs can be used to extract text, classify material, and detect visual elements.

You can ask Codex to:

  • explain a software error screenshot;
  • find a specified clause in a PDF;
  • compare two table screenshots;
  • extract information from a menu, price list, or manual;
  • turn scanned material into a Markdown draft.

For example:

Read this PDF and find every paragraph containing “automatic renewal,” “data retention,” or “refund.”
Return the keyword, quotation, page number, and impact on an ordinary user.
If the page number cannot be confirmed, mark it for review instead of guessing.

Small text, rotation, low-resolution scans, and identity numbers remain high-risk. Use dedicated OCR or human review when exact transcription matters. Visual understanding is not the same as perfectly accurate text recognition.

7. Create a small tool instead of learning an entire programming language

People often need small tools that do not exist as ready-made software: batch renaming, image compression, invoice summaries, file conversion, a simple webpage, or a personal portfolio.

You can describe the goal directly:

Create a simple web tool:
Users can drag in multiple CSV files, click Merge, and download one combined file.
Show the file count, total row count, and a list of files with errors.
Do not upload files to a server; process everything locally in the browser.
Provide usage instructions and run a local test with a sample.

Codex can generate a webpage, script, or small automation tool and run basic tests. You do not need to learn all of HTML, CSS, or Python first, but you still need to define privacy requirements, inputs, outputs, and acceptance criteria.

The goal is not the most complicated program. It is a usable, inspectable tool with clear boundaries.

8. Audit files, projects, and processes for problems

Codex is also useful for finding problems, not just creating new things. Ask it to inspect a workspace and return an exception report.

For example:

Audit the documentation in this project:
- find broken links;
- find inconsistent spelling of the same term;
- find skipped heading levels;
- find English and Chinese pages without corresponding links;
- do not modify files; create audit.md first and sort findings by severity.

It can also check:

  • duplicate numbers in spreadsheets;
  • file names that violate a naming rule;
  • contracts missing attachments;
  • abnormal dates in a directory;
  • a batch of articles missing titles, summaries, or sources.

Start with a read-only audit before allowing changes. This is a safer sequence.

9. Turn one-off work into a reusable workflow

If you repeat the same steps every week, ask Codex to turn them into rules, a script, or a reusable Skill.

OpenAI’s Codex page recently introduced Record & Replay: in supported environments, you can demonstrate a workflow and turn the demonstration into a reusable Skill. Even when that feature is unavailable, Codex can write the steps as workflow.md or a script.

For example:

Every Monday process last week's customer feedback:
1. read the inbox folder;
2. remove completely blank records;
3. classify by product, issue type, and severity;
4. count each category;
5. create feedback-report.md;
6. move uncertain records to a review folder.
Turn this into reusable instructions and list the input files that must be confirmed before each run.

Codex has now moved from answering one question to helping you build a repeatable work system.

How to connect the Codex mode in the ChatGPT desktop app

Codex is now integrated into ChatGPT, so the desktop application is called ChatGPT. In the app’s mode selector, you can switch between Work and Codex. This section describes connecting the Codex mode to UnifyLLM through CC Switch. Under the current Codex by CCS workflow, a ChatGPT account login is not required for a custom provider, and Codex does not need a separate login.

Preparation

  1. Install the ChatGPT desktop app. Windows users can also install it from the Microsoft Store. Open the app after installation; this third-party-provider path does not require signing in to ChatGPT.
  2. Install and open CC Switch. It writes provider configuration to the location used by ChatGPT’s Codex mode.
  3. Create a dedicated API key in the UnifyLLM console. Never expose the real key in an article, screenshot, or public repository.

Add UnifyLLM in CC Switch

Open provider management in CC Switch and follow the Add Provider flow to add a unified provider:

Provider name: UnifyLLM
Preset type: NewAPI
Enable Codex: Yes
Root API address: https://api.unifyllm.com
API format: Native Responses format
API key: paste the dedicated key created in UnifyLLM

Open ChatGPT after saving, switch to Codex mode, enter Settings, and click Edit Provider. The request address should normally be shown as:

https://api.unifyllm.com/v1

The root API address should be https://api.unifyllm.com; let CC Switch add /v1. Do not enter /v1 manually in the root address, or the request path may contain it twice and fail. If the UI offers Get Models, choose an available model from the list. You can also enter an exact model ID such as gpt-5.6-sol; use the current console model list and account permissions as the source of truth.

Save and verify

After saving the provider, reopen ChatGPT, switch to Codex mode, and send a short request first:

Read the current project directory, list the files you can see, and explain what actions you could take next. Do not modify any files.

If the desktop app responds, open UnifyLLM usage logs and verify the model name, token count, and charge. For an invalid URL, missing model, or 401 error, check in this order:

  • the request address contains exactly one /v1;
  • the API key is complete, has no extra spaces, and is still active;
  • the model ID exactly matches the name shown in the UnifyLLM console;
  • CC Switch and the ChatGPT desktop app are compatible current versions.

Codex configuration formats can change as the ChatGPT desktop app changes. Prefer the current CC Switch UI and UnifyLLM’s Codex by CCS guide instead of editing an old TOML file by hand. Work and Codex are different modes inside ChatGPT; enable Codex in CC Switch and test after switching ChatGPT to Codex mode. Follow least-privilege practices, separate keys, and require human confirmation for important actions.

How ordinary users should delegate work to Codex

A good task usually contains five parts:

  1. where the input is;
  2. what the desired result is;
  3. where the output should go;
  4. what must not happen;
  5. how to verify completion.

An inefficient request is:

Organize these files for me.

A better request is:

Read the PDFs and Word files in the current folder and classify them as contracts, invoices, resumes, or other.
First create proposed-plan.md. Do not move or delete anything.
After I approve it, put copies in a sorted folder and report the file count, uncertain files, and classification rationale.

The closer your description is to a work order, the easier it is for Codex to deliver something you can verify.

Safety boundaries: Codex is not autopilot

Codex can take actions, but an action is not automatically correct. For important files and external systems:

  • copy before modifying;
  • plan before executing;
  • audit read-only before batch changes;
  • do not put API keys, passwords, or private material in unnecessary workspaces;
  • require logs, sources, and change reports;
  • have humans review financial, legal, medical, and externally published content;
  • require explicit confirmation before deleting, sending, publishing, or overwriting.

The official Codex documentation also treats permission modes, project context, and reviewable deliverables as important concepts. Desktop, web, cloud, and plugin capabilities depend on the current account, platform, and environment; use the current interface as the final reference.

Conclusion

Ordinary users do not need to become programmers before using Codex. If a task involves files, spreadsheets, documents, webpages, scripts, repetitive steps, or a concrete deliverable, Codex may be able to handle part of it.

It works best when the goal is clear, the inputs are explicit, the process is inspectable, and the result can be reviewed.

The real barrier is not code. It is task definition. You do not need to describe every implementation detail, but you do need to explain what should be delivered, what must not happen, and how to prove it is correct.

References